#pragma once
#pragma warning(disable:4996)
//#include <string>
//// create the pers and debts namespaces
//namespace pers
//{
//	struct Person
//	{
//		std::string fname;
//		std::string lname;
//	};
//	void getPerson(Person&);
//	void showPerson(const Person&);
//}
//
//namespace debts
//{
//	using namespace pers;
//	struct Debt
//	{
//		Person name;
//		double amount;
//	};
//	void getDebt(Debt&);
//	void showDebt(const Debt&);
//	double sumDebts(const Debt ar[], int n);
//}

// stock00.h -- Stock class interface
// version 00
//#ifndef STOCK00_H_
//#define STOCK00_H_
//
//#include <string>
//
//class Stock		// class declaration
//{
//private:
//	std::string company;
//	long shares;
//	double share_val;
//	double total_val;
//	void set_tot() { total_val = shares * share_val; }
//public:
//	void acquire(const std::string& co, long n, double pr);
//	void buy(long num, double price);
//	void sell(long num, double price);
//	void update(double price);
//	void show();
//};		// note semicolon at the end
//
//#endif // STOCK00_H_

// stock10.h -- Stock class declaration with constructors, destructor added
//#ifndef STOCK10_H_
//#define STOCK10_H_
//#include <string>
//
//class Stock
//{
//private:
//	std::string company;
//	long shares;
//	double share_val;
//	double total_val;
//	void set_tot() { total_val = shares * share_val; }
//public:
//// two constructors
//	Stock();		// default constructor
//	Stock(const std::string& co, long n = 0, double pr = 0.0);
//	~Stock();		// noisy destructor
//	void buy(long num, double price);
//	void sell(long num, double price);
//	void update(double price);
//	void show();
//};
//
//#endif // !STOCK10_H_

// stock20.h -- augmented version
//#ifndef STOCK20_H_
//#define STOCK20_H_
//#include <string>
//
//class Stock
//{
//private:
//	std::string company;
//	long shares;
//	double share_val;
//	double total_val;
//	void set_tot() { total_val = shares * share_val; }
//public:
//	Stock();		// default constructor
//	Stock(const std::string& co, long n = 0, double pr = 0.0);
//	~Stock();		// do-nothing destructor
//	void buy(long num, double price);
//	void sell(long num, double price);
//	void update(double price);
//	void show() const;
//	const Stock& topval(const Stock& s) const;
//};
//
//#endif

// stack.h -- class definition for the stack ADT
//#ifndef STACK_H_
//#define STACK_H_
//
//typedef unsigned long Item;
//
//class Stack
//{
//private:
//	enum { MAX = 10 };		// constant specific to class
//	Item items[MAX];		// holds stack items
//	int top;				// index for top stack item
//public:
//	Stack();
//	bool isempty() const;
//	bool isfull() const;
//	// push() returns false if stack already is full, true otherwise
//	bool push(const Item& item);	// add item to stack
//	
//	// pop() returns false if stack already is empty, true otherwise
//	bool pop(Item& item);			// pop top into item
//};
//
//#endif // !STACK_H_

// vect.h -- Vector class with <<, mode state
//#ifndef VECTOR_H_
//#define VECTOR_H_
//#include <iostream>
//namespace VECTOR
//{
//	class Vector
//	{
//	public:
//		enum Mode {RECT, POL};
//	// RECT for rectangular, POL for Polar modes
//	private:
//		double x;		// horizontal value
//		double y;		// vertical value
//		double mag;		// length of vector
//		double ang;		// direction of vector in degrees
//		Mode mode;		// RECT or POL
//	// private methods for setting values
//		void set_mag();
//		void set_ang();
//		void set_x();
//		void set_y();
//	public:
//		Vector();
//		Vector(double n1, double n2, Mode form = RECT);
//		void reset(double n1, double n2, Mode form = RECT);
//		~Vector();
//		double xval() const{ return x; }		// report x value
//		double yval() const { return y; }		// report y value
//		double magval() const { return mag; }	// report magnitude
//		double angval() const { return ang; }	// report angle
//		void polar_mode();						// set mode to POL
//		void rect_mode();						// set mode to RECT
//	// operator overloading
//		Vector operator+(const Vector& b) const;
//		Vector operator-(const Vector& b) const;
//		Vector operator-() const;
//		Vector operator*(double n) const;
//	// friends
//		friend Vector operator*(double n, const Vector& a);
//		friend std::ostream&
//			operator<<(std::ostream& os, const Vector& v);
//	};
//}	// end namespace VECTOR
//#endif // !VECTOR_H_

// string1.h -- fixed and augmented string class definition

//#ifndef STRING1_H_
//#define STRING1_H_
//#include <iostream>
//using std::ostream;
//using std::istream;
//
//class String
//{
//private:
//	char* str;					// pointer to string
//	int len;					// length of string
//	static int num_strings;		//	number of objects
//	static const int CINLIM = 80;	// cin input limit
//public:
//	// constructors and other methods
//	String(const char* s);		// constructor
//	String();					// default constructor
//	String(const String&);		// copy constructor
//	~String();					// destructor
//	int length() const { return len; }
//	// overloaded operator methods
//	String& operator=(const String&);
//	String& operator=(const char*);
//	char& operator[](int i);
//	const char& operator[](int i) const;
//	// overloaded operator friends
//	friend bool operator<(const String& st1, const String& st2);
//	friend bool operator>(const String& st1, const String& st2);
//	friend bool operator==(const String& st1, const String& st2);
//	friend ostream& operator<<(ostream& os, const String& st);
//	friend istream& operator>>(istream& is, String& st);
//	// static function
//	static int HowMany();
//};
//#endif // !STRING1_H_

// queue.h -- interface for q queue
//#ifndef QUEUE_H_
//#define QUEUE_H_
//// This queue will contain Customer items
//class Customer
//{
//private:
//	long arrive;		// arrival time for customer
//	int processtime;	// processing time for customer
//public:
//	Customer() { arrive = processtime = 0; }
//	void set(long when);
//	long when() const { return arrive; }
//	int ptime() const { return processtime; }
//};
//
//typedef Customer Item;
//
//class Queue
//{
//private:
//// class scope definitions
//	// Node is nested structure definition local to this c
//	struct Node
//	{
//		Item item;
//		struct Node* next;
//	};
//	enum {Q_SIZE = 10};
//// private class members
//	Node* front;		// pointer to front of Queue
//	Node* rear;			// pointer to rear of Queue
//	int items;			// current number of items in Queue
//	const int qsize;	// maximum number of items in Queue
//	// preemptive definitions to prevent public copying
//	Queue(const Queue& q) : qsize(0) { }
//	Queue& operator=(const Queue& q) { return *this; }
//public:
//	Queue(int qs = Q_SIZE);		// create queue with a qs limit
//	~Queue();
//	bool isempty() const;
//	bool isfull() const;
//	int queuecount() const;
//	bool enqueue(const Item& item);	// add item to end
//	bool dequeue(Item& item);		// remove item from front
//};
//#endif // !QUEUE_H_

// tabtenn1.h -- a table-tennis base class
//#ifndef TABTENN1_H_
//#define TABTENN1_H_
//#include <string>
//using std::string;
//// simple base class
//class TableTennisPlayer
//{
//private:
//	string firstname;
//	string lastname;
//	bool hasTable;
//public:
//	TableTennisPlayer(const string& fn = "none",
//					  const string& ln = "none",
//					  bool ht = false);
//	void Name() const;
//	bool HasTable() const { return hasTable; };
//	void ResetTable(bool v) { hasTable = v; };
//};
//
//// simple derived class
//class RatedPlayer :public TableTennisPlayer
//{
//private:
//	unsigned int rating;
//public:
//	RatedPlayer(unsigned int r = 0, const string& fn = "none",
//				const string& ln = "none", bool ht = false);
//	RatedPlayer(unsigned int r, const TableTennisPlayer& tp);
//	unsigned int Rating() const { return rating; }
//	void ResetRaging(unsigned int r) { rating = r; }
//};
//#endif // !TABTENN1_H_

// brass.h -- bank account classes
//#ifndef BRASS_H_
//#define BRASS_H_
//#include <string>
//// Brass Account Class
//class Brass
//{
//private:
//	std::string fullName;
//	long acctNum;
//	double balance;
//public:
//	Brass(const std::string& s = "Nullbody", long an = -1,
//				double bal = 0.0);
//	void Deposit(double amt);
//	virtual void Withdraw(double amt);
//	double Balance() const;
//	virtual void ViewAcct() const;
//	virtual ~Brass() {}
//};
//
////Brass Plus Account Class
//class BrassPlus :public Brass
//{
//private:
//	double maxLoan;
//	double rate;
//	double owesBank;
//public:
//	BrassPlus(const std::string& s = "Nullbody", long an = -1,
//		double bal = 0.0, double ml = 500,
//		double r = 0.11125);
//	BrassPlus(const Brass& ba, double ml = 500, double r = 0.11125);
//	virtual void ViewAcct() const;
//	virtual void Withdraw(double amt);
//	void ResetMax(double m) { maxLoan = m; }
//	void ResetRate(double r) { rate = r; }
//	void ResetOwes() { owesBank = 0; }
//};
//#endif // !BRASS_H_

// acctabc.h -- bank account classes
//#ifndef ACCTABC_H_
//#define ACCTABC_H_
//#include <iostream>
//#include <string>
//
//// Abstract Base Class
//class AcctABC
//{
//private:
//	std::string fullName;
//	long acctNum;
//	double balance;
//protected:
//	struct Formatting
//	{
//		std::ios_base::fmtflags flag;
//		std::streamsize pr;
//	};
//	const std::string& FullName() const { return fullName; }
//	long AcctNum() const { return acctNum; }
//	Formatting SetFormat() const;
//	void Restore(Formatting& f) const;
//public:
//	AcctABC(const std::string& s = "Nullbody", long an = -1,
//		double bal = 0.0);
//	void Deposit(double amt);
//	virtual void Withdraw(double amt) = 0;		// pure virtual function
//	double Balance() const { return balance; }
//	virtual void ViewAcct() const = 0;			// pure virtual function
//	virtual ~AcctABC() {}
//};
//
//// Brass Account Class
//class Brass :public AcctABC
//{
//public:
//	Brass(const std::string& s = "Nullbody", long an = -1,
//		double bal = 0.0) :AcctABC(s, an, bal) {}
//	virtual void Withdraw(double amt);
//	virtual void ViewAcct() const;
//	virtual ~Brass() {}
//};
//
//// Brass Plus Account Class
//class BrassPlus :public AcctABC
//{
//private:
//	double maxLoan;
//	double rate;
//	double owesBank;
//public:
//	BrassPlus(const std::string& s = "Nullbody", long an = -1,
//		double bal = 0.0, double ml = 500,
//		double r = 0.10);
//	BrassPlus(const Brass& ba, double ml = 500, double r = 0.1);
//	virtual void ViewAcct() const;
//	virtual void Withdraw(double amt);
//	void ResetMax(double m) { maxLoan = m; }
//	void ResetRate(double r) { rate = r; }
//	void ResetOwes() { owesBank = 0; }
//};
//#endif // !ACCTABC_H_
